package org.example.autofilearchiver.tool.fileTool;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;

public class FileUtils {
    /**
     * 获取到path下一级路径的所有文件的绝对路径，不包含文件夹
     *
     * @param path 传入的path
     * @return 所有文件的绝对路径
     */
    public static List<String> getNextLevelFilesAbsolutePath(String path) {
        List<String> filePaths = new ArrayList<>();
        File directory = new File(path);

        // 检查路径是否有效且为目录
        if (directory.exists() && directory.isDirectory()) {
            // 获取下一级文件和文件夹
            File[] files = directory.listFiles();
            if (files != null) {
                for (File file : files) {
                    // 只添加文件，不添加文件夹
                    if (file.isFile()) {
                        filePaths.add(file.getAbsolutePath());
                    }
                }
            }
        } else {
            // 路径无效或不是目录，可以抛出异常或记录日志
            System.err.println("Invalid path or not a directory: " + path);
        }

        return filePaths;
    }

    /**
     * 检查给定路径是否存在，如果不存在则创建该路径的文件夹
     *
     * @param filePath 文件路径
     * @throws IOException 如果文件夹创建失败则抛出异常
     */
    public static void createDirectoriesIfNotExists(String filePath) throws IOException {
        // 获取文件路径的父路径（即文件夹路径）  
        Path path = Paths.get(filePath);
        Path parentPath = path.getParent();

        // 如果父路径不为空且不存在，则创建文件夹  
        if (parentPath != null && !Files.exists(parentPath)) {
            Files.createDirectories(parentPath);
//            System.out.println("目录已创建: " + parentPath);
        } else if (parentPath == null) {
            // 如果传入的路径没有父路径，说明传入的可能是一个根目录下的文件  
            // 根据需求，这种情况通常不需要创建文件夹  
//            System.out.println("传入的路径没有父目录，无需创建文件夹。");
        } else {
            // 父路径已经存在  
//            System.out.println("目录已存在: " + parentPath);
        }
    }


    /**
     * 获取到指定文件夹内所有文件夹的绝对路径
     *
     * @param folderPath 指定的文件夹名字
     * @return filePaths 所有的文件的绝对路径
     */
    public static List<String> getAllFilePaths(String folderPath) {
        List<String> filePaths = new ArrayList<>();
        File folder = new File(folderPath);

        // 检查传入的路径是否是一个有效的文件夹
        if (folder.exists() && folder.isDirectory()) {
            // 调用递归方法遍历文件夹和子文件夹
            getFilePathsRecursively(folder, filePaths);
        } else {
            // 如果路径无效，可以抛出异常或者返回一个空列表
            // 这里选择返回一个空列表
            System.err.println("Invalid folder path: " + folderPath);
        }

        return filePaths;
    }

    /**
     * 获取到指定文件夹内所有文件的绝对路径
     *
     * @param folder    指定的文件夹名字
     * @param filePaths 储存文件的绝对路径
     */
    private static void getFilePathsRecursively(File folder, List<String> filePaths) {
        // 获取文件夹中的所有文件和子文件夹
        File[] files = folder.listFiles();

        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    // 如果是文件，则添加其绝对路径到列表中
                    filePaths.add(file.getAbsolutePath());
                } else if (file.isDirectory()) {
                    // 如果是文件夹，则递归调用自身
                    getFilePathsRecursively(file, filePaths);
                }
            }
        }
    }

    /**
     * 判断给定路径是文件路径还是文件夹路径
     *
     * @param path 要判断的路径
     * @return 如果路径是文件夹返回true，如果是文件返回false
     * @throws IllegalArgumentException 如果路径为空或null
     */
    public static boolean isDirectory(String path) {
        // 检查路径是否为空或null
        if (path == null || path.isEmpty()) {
            throw new IllegalArgumentException("Path cannot be null or empty");
        }

        // 创建File对象
        File file = new File(path);

        // 判断File对象是否是目录
        return file.isDirectory();
    }

    /**
     * 从完整路径中提取文件名（不含后缀名）
     *
     * @param filePath 文件的完整路径
     * @return 去除后缀名后的文件名
     * @throws IllegalArgumentException 如果filePath为空、null或格式不正确
     */
    public static String getFileNameWithoutExtension(String filePath) {
        // 检查filePath的有效性
        if (filePath == null || filePath.isEmpty()) {
            throw new IllegalArgumentException("文件路径不能为空或null");
        }

        // 查找最后一个反斜杠（用于Windows路径）或斜杠（用于Unix/Linux路径）
        int lastSeparatorIndex = filePath.lastIndexOf('\\') != -1 ? filePath.lastIndexOf('\\') : filePath.lastIndexOf('/');

        // 如果没有找到分隔符，说明可能是一个没有路径的文件名
        if (lastSeparatorIndex == -1) {
            // 此时直接查找最后一个点，可能是文件名中的点
            int lastDotIndex = filePath.lastIndexOf('.');
            // 如果存在点且不是文件名的第一个字符，则截取点之前的部分作为文件名
            if (lastDotIndex != -1 && lastDotIndex != 0) {
                return filePath.substring(0, lastDotIndex);
            } else {
                // 如果没有点或点是文件名的第一个字符，则整个字符串作为文件名返回（尽管这可能不是一个有效的文件名）
                return filePath;
            }
        } else {
            // 从最后一个分隔符后开始查找最后一个点
            String fileName = filePath.substring(lastSeparatorIndex + 1);
            int dotIndex = fileName.lastIndexOf('.');
            // 如果找到点且点不在文件名的开头，返回点之前的部分
            if (dotIndex != -1 && dotIndex != 0) {
                return fileName.substring(0, dotIndex);
            } else {
                // 如果没有找到点或点在文件名的开头，返回整个文件名
                return fileName;
            }
        }
    }

    /**
     * 把文件移动到指定的文件夹下面
     * @param sourcePath 源文件路径
     * @param targetPath 指定的文件路径
     * @throws IOException 错误
     */
    public static void moveFile(String sourcePath, String targetPath) throws IOException {
        File sourceFile = new File(sourcePath);
        File targetFile = new File(targetPath);

        File targetDir = targetFile.getParentFile();
        if (targetDir == null) {
            throw new IllegalArgumentException("目标路径的格式不正确，无法解析出父目录");
        }

        // 如果目标目录不存在，则创建它
        if (!targetDir.exists()) {
            targetDir.mkdirs();
        }

        boolean success = sourceFile.renameTo(targetFile);
        if (!success) {
            throw new IOException("文件移动失败");
        }
    }

}